
circular_singly:     file format elf32-littlearm


Disassembly of section .init:

00010354 <_init>:
   10354:	e1a0c00d 	mov	ip, sp
   10358:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   1035c:	e24cb004 	sub	fp, ip, #4
   10360:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

00010364 <putchar@plt-0x14>:
   10364:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   10368:	e59fe004 	ldr	lr, [pc, #4]	; 10374 <_init+0x20>
   1036c:	e08fe00e 	add	lr, pc, lr
   10370:	e5bef008 	ldr	pc, [lr, #8]!
   10374:	00011368 	.word	0x00011368

00010378 <putchar@plt>:
   10378:	e28fc600 	add	ip, pc, #0, 12
   1037c:	e28cca11 	add	ip, ip, #69632	; 0x11000
   10380:	e5bcf368 	ldr	pc, [ip, #872]!	; 0x368

00010384 <printf@plt>:
   10384:	e28fc600 	add	ip, pc, #0, 12
   10388:	e28cca11 	add	ip, ip, #69632	; 0x11000
   1038c:	e5bcf360 	ldr	pc, [ip, #864]!	; 0x360

00010390 <puts@plt>:
   10390:	e28fc600 	add	ip, pc, #0, 12
   10394:	e28cca11 	add	ip, ip, #69632	; 0x11000
   10398:	e5bcf358 	ldr	pc, [ip, #856]!	; 0x358

0001039c <malloc@plt>:
   1039c:	e28fc600 	add	ip, pc, #0, 12
   103a0:	e28cca11 	add	ip, ip, #69632	; 0x11000
   103a4:	e5bcf350 	ldr	pc, [ip, #848]!	; 0x350

000103a8 <abort@plt>:
   103a8:	e28fc600 	add	ip, pc, #0, 12
   103ac:	e28cca11 	add	ip, ip, #69632	; 0x11000
   103b0:	e5bcf348 	ldr	pc, [ip, #840]!	; 0x348

000103b4 <__deregister_frame_info@plt>:
   103b4:	e28fc600 	add	ip, pc, #0, 12
   103b8:	e28cca11 	add	ip, ip, #69632	; 0x11000
   103bc:	e5bcf340 	ldr	pc, [ip, #832]!	; 0x340

000103c0 <__uClibc_main@plt>:
   103c0:	e28fc600 	add	ip, pc, #0, 12
   103c4:	e28cca11 	add	ip, ip, #69632	; 0x11000
   103c8:	e5bcf338 	ldr	pc, [ip, #824]!	; 0x338

000103cc <__register_frame_info@plt>:
   103cc:	e28fc600 	add	ip, pc, #0, 12
   103d0:	e28cca11 	add	ip, ip, #69632	; 0x11000
   103d4:	e5bcf330 	ldr	pc, [ip, #816]!	; 0x330

Disassembly of section .text:

000103d8 <_start>:
   103d8:	e3a0b000 	.word	0xe3a0b000
   103dc:	e3a0e000 	.word	0xe3a0e000
   103e0:	e49d1004 	.word	0xe49d1004
   103e4:	e1a0200d 	.word	0xe1a0200d
   103e8:	e52d2004 	.word	0xe52d2004
   103ec:	e52d0004 	.word	0xe52d0004
   103f0:	e59fc010 	.word	0xe59fc010
   103f4:	e52dc004 	.word	0xe52dc004
   103f8:	e59f000c 	.word	0xe59f000c
   103fc:	e59f300c 	.word	0xe59f300c
   10400:	eaffffee 	.word	0xeaffffee
   10404:	ebffffe7 	.word	0xebffffe7
   10408:	00011120 	.word	0x00011120
   1040c:	000110a8 	.word	0x000110a8
   10410:	00010354 	.word	0x00010354

00010414 <deregister_tm_clones>:
   10414:	e59f301c 	ldr	r3, [pc, #28]	; 10438 <deregister_tm_clones+0x24>
   10418:	e59f001c 	ldr	r0, [pc, #28]	; 1043c <deregister_tm_clones+0x28>
   1041c:	e0603003 	rsb	r3, r0, r3
   10420:	e3530006 	cmp	r3, #6
   10424:	912fff1e 	bxls	lr
   10428:	e59f3010 	ldr	r3, [pc, #16]	; 10440 <deregister_tm_clones+0x2c>
   1042c:	e3530000 	cmp	r3, #0
   10430:	012fff1e 	bxeq	lr
   10434:	e12fff13 	bx	r3
   10438:	00021713 	.word	0x00021713
   1043c:	00021710 	.word	0x00021710
   10440:	00000000 	.word	0x00000000

00010444 <register_tm_clones>:
   10444:	e59f1024 	ldr	r1, [pc, #36]	; 10470 <register_tm_clones+0x2c>
   10448:	e59f0024 	ldr	r0, [pc, #36]	; 10474 <register_tm_clones+0x30>
   1044c:	e0601001 	rsb	r1, r0, r1
   10450:	e1a01141 	asr	r1, r1, #2
   10454:	e0811fa1 	add	r1, r1, r1, lsr #31
   10458:	e1b010c1 	asrs	r1, r1, #1
   1045c:	012fff1e 	bxeq	lr
   10460:	e59f3010 	ldr	r3, [pc, #16]	; 10478 <register_tm_clones+0x34>
   10464:	e3530000 	cmp	r3, #0
   10468:	012fff1e 	bxeq	lr
   1046c:	e12fff13 	bx	r3
   10470:	00021710 	.word	0x00021710
   10474:	00021710 	.word	0x00021710
   10478:	00000000 	.word	0x00000000

0001047c <__do_global_dtors_aux>:
   1047c:	e92d4010 	push	{r4, lr}
   10480:	e59f402c 	ldr	r4, [pc, #44]	; 104b4 <__do_global_dtors_aux+0x38>
   10484:	e5d43000 	ldrb	r3, [r4]
   10488:	e3530000 	cmp	r3, #0
   1048c:	18bd8010 	popne	{r4, pc}
   10490:	ebffffdf 	bl	10414 <deregister_tm_clones>
   10494:	e59f301c 	ldr	r3, [pc, #28]	; 104b8 <__do_global_dtors_aux+0x3c>
   10498:	e3530000 	cmp	r3, #0
   1049c:	0a000001 	beq	104a8 <__do_global_dtors_aux+0x2c>
   104a0:	e59f0014 	ldr	r0, [pc, #20]	; 104bc <__do_global_dtors_aux+0x40>
   104a4:	ebffffc2 	bl	103b4 <__deregister_frame_info@plt>
   104a8:	e3a03001 	mov	r3, #1
   104ac:	e5c43000 	strb	r3, [r4]
   104b0:	e8bd8010 	pop	{r4, pc}
   104b4:	00021710 	.word	0x00021710
   104b8:	00000000 	.word	0x00000000
   104bc:	00011614 	.word	0x00011614

000104c0 <frame_dummy>:
   104c0:	e59f3040 	ldr	r3, [pc, #64]	; 10508 <frame_dummy+0x48>
   104c4:	e92d4010 	push	{r4, lr}
   104c8:	e3530000 	cmp	r3, #0
   104cc:	0a000002 	beq	104dc <frame_dummy+0x1c>
   104d0:	e59f1034 	ldr	r1, [pc, #52]	; 1050c <frame_dummy+0x4c>
   104d4:	e59f0034 	ldr	r0, [pc, #52]	; 10510 <frame_dummy+0x50>
   104d8:	ebffffbb 	bl	103cc <__register_frame_info@plt>
   104dc:	e59f0030 	ldr	r0, [pc, #48]	; 10514 <frame_dummy+0x54>
   104e0:	e5903000 	ldr	r3, [r0]
   104e4:	e3530000 	cmp	r3, #0
   104e8:	1a000001 	bne	104f4 <frame_dummy+0x34>
   104ec:	e8bd4010 	pop	{r4, lr}
   104f0:	eaffffd3 	b	10444 <register_tm_clones>
   104f4:	e59f301c 	ldr	r3, [pc, #28]	; 10518 <frame_dummy+0x58>
   104f8:	e3530000 	cmp	r3, #0
   104fc:	0afffffa 	beq	104ec <frame_dummy+0x2c>
   10500:	e12fff33 	blx	r3
   10504:	eafffff8 	b	104ec <frame_dummy+0x2c>
   10508:	00000000 	.word	0x00000000
   1050c:	00021714 	.word	0x00021714
   10510:	00011614 	.word	0x00011614
   10514:	00021620 	.word	0x00021620
   10518:	00000000 	.word	0x00000000

0001051c <display_debug>:
  int num;
  struct list * next;
};

void display_debug(struct list ** node)
{
   1051c:	e92d4800 	push	{fp, lr}
   10520:	e28db004 	add	fp, sp, #4
   10524:	e24dd010 	sub	sp, sp, #16
   10528:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;
  int i;
 
  src = * node;
   1052c:	e51b3010 	ldr	r3, [fp, #-16]
   10530:	e5933000 	ldr	r3, [r3]
   10534:	e50b3008 	str	r3, [fp, #-8]
  //for (i = 0, src; src != NULL; i++) {
  while (src) {
   10538:	ea000008 	b	10560 <display_debug+0x44>
    printf(" [%p:%d] ", src, src->num);
   1053c:	e51b3008 	ldr	r3, [fp, #-8]
   10540:	e5933000 	ldr	r3, [r3]
   10544:	e1a02003 	mov	r2, r3
   10548:	e51b1008 	ldr	r1, [fp, #-8]
   1054c:	e59f0028 	ldr	r0, [pc, #40]	; 1057c <display_debug+0x60>
   10550:	ebffff8b 	bl	10384 <printf@plt>
    src = src->next;
   10554:	e51b3008 	ldr	r3, [fp, #-8]
   10558:	e5933004 	ldr	r3, [r3, #4]
   1055c:	e50b3008 	str	r3, [fp, #-8]
  struct list * src;
  int i;
 
  src = * node;
  //for (i = 0, src; src != NULL; i++) {
  while (src) {
   10560:	e51b3008 	ldr	r3, [fp, #-8]
   10564:	e3530000 	cmp	r3, #0
   10568:	1afffff3 	bne	1053c <display_debug+0x20>
    printf(" [%p:%d] ", src, src->num);
    src = src->next;
    //printf(" %p ", src);
  }
  printf("\n");
   1056c:	e3a0000a 	mov	r0, #10
   10570:	ebffff80 	bl	10378 <putchar@plt>
}
   10574:	e24bd004 	sub	sp, fp, #4
   10578:	e8bd8800 	pop	{fp, pc}
   1057c:	00011130 	.word	0x00011130

00010580 <reverse_perfect_debug>:

struct list * reverse_perfect_debug(struct list * node)
{
   10580:	e92d4800 	push	{fp, lr}
   10584:	e28db004 	add	fp, sp, #4
   10588:	e24dd020 	sub	sp, sp, #32
   1058c:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
  struct list * src, * des, * tmp;

  printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
   10590:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10594:	e5931004 	ldr	r1, [r3, #4]
   10598:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1059c:	e5933004 	ldr	r3, [r3, #4]
   105a0:	e5930004 	ldr	r0, [r3, #4]
   105a4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   105a8:	e5933004 	ldr	r3, [r3, #4]
   105ac:	e5933004 	ldr	r3, [r3, #4]
   105b0:	e5933004 	ldr	r3, [r3, #4]
   105b4:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   105b8:	e5922004 	ldr	r2, [r2, #4]
   105bc:	e5922004 	ldr	r2, [r2, #4]
   105c0:	e5922004 	ldr	r2, [r2, #4]
   105c4:	e5922004 	ldr	r2, [r2, #4]
   105c8:	e58d2004 	str	r2, [sp, #4]
   105cc:	e58d3000 	str	r3, [sp]
   105d0:	e1a03000 	mov	r3, r0
   105d4:	e1a02001 	mov	r2, r1
   105d8:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   105dc:	e59f00d0 	ldr	r0, [pc, #208]	; 106b4 <reverse_perfect_debug+0x134>
   105e0:	ebffff67 	bl	10384 <printf@plt>
  src = tmp = node;  // 指向第一个结点
   105e4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   105e8:	e50b300c 	str	r3, [fp, #-12]
   105ec:	e51b300c 	ldr	r3, [fp, #-12]
   105f0:	e50b3008 	str	r3, [fp, #-8]
  printf("src=node %p:%p \n", src, node);
   105f4:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   105f8:	e51b1008 	ldr	r1, [fp, #-8]
   105fc:	e59f00b4 	ldr	r0, [pc, #180]	; 106b8 <reverse_perfect_debug+0x138>
   10600:	ebffff5f 	bl	10384 <printf@plt>
  node = NULL; // 目前，链表node为空 (num, next 都为空)
   10604:	e3a03000 	mov	r3, #0
   10608:	e50b3018 	str	r3, [fp, #-24]	; 0xffffffe8
  printf("node=NULL:%p \n\n", node);
   1060c:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10610:	e59f00a4 	ldr	r0, [pc, #164]	; 106bc <reverse_perfect_debug+0x13c>
   10614:	ebffff5a 	bl	10384 <printf@plt>
  while (src) {
   10618:	ea00001b 	b	1068c <reverse_perfect_debug+0x10c>
    des = src; // des 指向要翻转的结点
   1061c:	e51b3008 	ldr	r3, [fp, #-8]
   10620:	e50b3010 	str	r3, [fp, #-16]
    printf("des=src %p:%p \n",des, src);
   10624:	e51b2008 	ldr	r2, [fp, #-8]
   10628:	e51b1010 	ldr	r1, [fp, #-16]
   1062c:	e59f008c 	ldr	r0, [pc, #140]	; 106c0 <reverse_perfect_debug+0x140>
   10630:	ebffff53 	bl	10384 <printf@plt>
    src = src->next; // 指向下一个要翻转的结点
   10634:	e51b3008 	ldr	r3, [fp, #-8]
   10638:	e5933004 	ldr	r3, [r3, #4]
   1063c:	e50b3008 	str	r3, [fp, #-8]
    printf("src=src->next %p:%p \n", src, src);
   10640:	e51b2008 	ldr	r2, [fp, #-8]
   10644:	e51b1008 	ldr	r1, [fp, #-8]
   10648:	e59f0074 	ldr	r0, [pc, #116]	; 106c4 <reverse_perfect_debug+0x144>
   1064c:	ebffff4c 	bl	10384 <printf@plt>
    des->next = node; // 链接到翻转后的链表
   10650:	e51b3010 	ldr	r3, [fp, #-16]
   10654:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   10658:	e5832004 	str	r2, [r3, #4]
    printf("des->next=node %p:%p \n", des->next, node);
   1065c:	e51b3010 	ldr	r3, [fp, #-16]
   10660:	e5933004 	ldr	r3, [r3, #4]
   10664:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   10668:	e1a01003 	mov	r1, r3
   1066c:	e59f0054 	ldr	r0, [pc, #84]	; 106c8 <reverse_perfect_debug+0x148>
   10670:	ebffff43 	bl	10384 <printf@plt>
    node = des;  // 为链接下一个做准备
   10674:	e51b3010 	ldr	r3, [fp, #-16]
   10678:	e50b3018 	str	r3, [fp, #-24]	; 0xffffffe8
    printf("node=des %p:%p \n\n", node, des);
   1067c:	e51b2010 	ldr	r2, [fp, #-16]
   10680:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10684:	e59f0040 	ldr	r0, [pc, #64]	; 106cc <reverse_perfect_debug+0x14c>
   10688:	ebffff3d 	bl	10384 <printf@plt>
  printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
  src = tmp = node;  // 指向第一个结点
  printf("src=node %p:%p \n", src, node);
  node = NULL; // 目前，链表node为空 (num, next 都为空)
  printf("node=NULL:%p \n\n", node);
  while (src) {
   1068c:	e51b3008 	ldr	r3, [fp, #-8]
   10690:	e3530000 	cmp	r3, #0
   10694:	1affffe0 	bne	1061c <reverse_perfect_debug+0x9c>
    des->next = node; // 链接到翻转后的链表
    printf("des->next=node %p:%p \n", des->next, node);
    node = des;  // 为链接下一个做准备
    printf("node=des %p:%p \n\n", node, des);
  }
  printf("return node : %p \n", node);
   10698:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   1069c:	e59f002c 	ldr	r0, [pc, #44]	; 106d0 <reverse_perfect_debug+0x150>
   106a0:	ebffff37 	bl	10384 <printf@plt>

  return node;  // 返回翻转后的链表
   106a4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
}
   106a8:	e1a00003 	mov	r0, r3
   106ac:	e24bd004 	sub	sp, fp, #4
   106b0:	e8bd8800 	pop	{fp, pc}
   106b4:	0001113c 	.word	0x0001113c
   106b8:	0001114c 	.word	0x0001114c
   106bc:	00011160 	.word	0x00011160
   106c0:	00011170 	.word	0x00011170
   106c4:	00011180 	.word	0x00011180
   106c8:	00011198 	.word	0x00011198
   106cc:	000111b0 	.word	0x000111b0
   106d0:	000111c4 	.word	0x000111c4

000106d4 <reverse_perfect_noreturn_debug>:

void  reverse_perfect_noreturn_debug(struct list ** node)
{
   106d4:	e92d4800 	push	{fp, lr}
   106d8:	e28db004 	add	fp, sp, #4
   106dc:	e24dd018 	sub	sp, sp, #24
   106e0:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  printf("[%p:%p:%p]\n", node, * node, ** node);
   106e4:	e51b3010 	ldr	r3, [fp, #-16]
   106e8:	e5931000 	ldr	r1, [r3]
   106ec:	e51b3010 	ldr	r3, [fp, #-16]
   106f0:	e5933000 	ldr	r3, [r3]
   106f4:	e5932004 	ldr	r2, [r3, #4]
   106f8:	e58d2000 	str	r2, [sp]
   106fc:	e5933000 	ldr	r3, [r3]
   10700:	e1a02001 	mov	r2, r1
   10704:	e51b1010 	ldr	r1, [fp, #-16]
   10708:	e59f00f4 	ldr	r0, [pc, #244]	; 10804 <reverse_perfect_noreturn_debug+0x130>
   1070c:	ebffff1c 	bl	10384 <printf@plt>
  //printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
  src = * node;  // 指向第一个结点
   10710:	e51b3010 	ldr	r3, [fp, #-16]
   10714:	e5933000 	ldr	r3, [r3]
   10718:	e50b3008 	str	r3, [fp, #-8]
  printf("src=node %p:%p \n", src, * node);
   1071c:	e51b3010 	ldr	r3, [fp, #-16]
   10720:	e5933000 	ldr	r3, [r3]
   10724:	e1a02003 	mov	r2, r3
   10728:	e51b1008 	ldr	r1, [fp, #-8]
   1072c:	e59f00d4 	ldr	r0, [pc, #212]	; 10808 <reverse_perfect_noreturn_debug+0x134>
   10730:	ebffff13 	bl	10384 <printf@plt>
  * node = NULL; // 目前，链表node为空 (num, next 都为空)
   10734:	e51b3010 	ldr	r3, [fp, #-16]
   10738:	e3a02000 	mov	r2, #0
   1073c:	e5832000 	str	r2, [r3]
  printf("node=NULL:%p \n\n", * node);
   10740:	e51b3010 	ldr	r3, [fp, #-16]
   10744:	e5933000 	ldr	r3, [r3]
   10748:	e1a01003 	mov	r1, r3
   1074c:	e59f00b8 	ldr	r0, [pc, #184]	; 1080c <reverse_perfect_noreturn_debug+0x138>
   10750:	ebffff0b 	bl	10384 <printf@plt>
  while (src) {
   10754:	ea000020 	b	107dc <reverse_perfect_noreturn_debug+0x108>
    des = src; // des 指向要翻转的结点
   10758:	e51b3008 	ldr	r3, [fp, #-8]
   1075c:	e50b300c 	str	r3, [fp, #-12]
    printf("des=src %p:%p \n",des, src);
   10760:	e51b2008 	ldr	r2, [fp, #-8]
   10764:	e51b100c 	ldr	r1, [fp, #-12]
   10768:	e59f00a0 	ldr	r0, [pc, #160]	; 10810 <reverse_perfect_noreturn_debug+0x13c>
   1076c:	ebffff04 	bl	10384 <printf@plt>
    src = src->next; // 指向下一个要翻转的结点
   10770:	e51b3008 	ldr	r3, [fp, #-8]
   10774:	e5933004 	ldr	r3, [r3, #4]
   10778:	e50b3008 	str	r3, [fp, #-8]
    printf("src=src->next %p:%p \n", src, src);
   1077c:	e51b2008 	ldr	r2, [fp, #-8]
   10780:	e51b1008 	ldr	r1, [fp, #-8]
   10784:	e59f0088 	ldr	r0, [pc, #136]	; 10814 <reverse_perfect_noreturn_debug+0x140>
   10788:	ebfffefd 	bl	10384 <printf@plt>
    des->next = * node; // 链接到翻转后的链表
   1078c:	e51b3010 	ldr	r3, [fp, #-16]
   10790:	e5932000 	ldr	r2, [r3]
   10794:	e51b300c 	ldr	r3, [fp, #-12]
   10798:	e5832004 	str	r2, [r3, #4]
    printf("des->next=node %p:%p \n", des->next, * node);
   1079c:	e51b300c 	ldr	r3, [fp, #-12]
   107a0:	e5931004 	ldr	r1, [r3, #4]
   107a4:	e51b3010 	ldr	r3, [fp, #-16]
   107a8:	e5933000 	ldr	r3, [r3]
   107ac:	e1a02003 	mov	r2, r3
   107b0:	e59f0060 	ldr	r0, [pc, #96]	; 10818 <reverse_perfect_noreturn_debug+0x144>
   107b4:	ebfffef2 	bl	10384 <printf@plt>
    * node = des;  // 为链接下一个做准备
   107b8:	e51b3010 	ldr	r3, [fp, #-16]
   107bc:	e51b200c 	ldr	r2, [fp, #-12]
   107c0:	e5832000 	str	r2, [r3]
    printf("node=des %p:%p \n\n", * node, des);
   107c4:	e51b3010 	ldr	r3, [fp, #-16]
   107c8:	e5933000 	ldr	r3, [r3]
   107cc:	e51b200c 	ldr	r2, [fp, #-12]
   107d0:	e1a01003 	mov	r1, r3
   107d4:	e59f0040 	ldr	r0, [pc, #64]	; 1081c <reverse_perfect_noreturn_debug+0x148>
   107d8:	ebfffee9 	bl	10384 <printf@plt>
  //printf("%p:%p:%p:%p:%p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
  src = * node;  // 指向第一个结点
  printf("src=node %p:%p \n", src, * node);
  * node = NULL; // 目前，链表node为空 (num, next 都为空)
  printf("node=NULL:%p \n\n", * node);
  while (src) {
   107dc:	e51b3008 	ldr	r3, [fp, #-8]
   107e0:	e3530000 	cmp	r3, #0
   107e4:	1affffdb 	bne	10758 <reverse_perfect_noreturn_debug+0x84>
    des->next = * node; // 链接到翻转后的链表
    printf("des->next=node %p:%p \n", des->next, * node);
    * node = des;  // 为链接下一个做准备
    printf("node=des %p:%p \n\n", * node, des);
  }
  printf("reverse_perfect end of node : %p \n", * node);
   107e8:	e51b3010 	ldr	r3, [fp, #-16]
   107ec:	e5933000 	ldr	r3, [r3]
   107f0:	e1a01003 	mov	r1, r3
   107f4:	e59f0024 	ldr	r0, [pc, #36]	; 10820 <reverse_perfect_noreturn_debug+0x14c>
   107f8:	ebfffee1 	bl	10384 <printf@plt>
}
   107fc:	e24bd004 	sub	sp, fp, #4
   10800:	e8bd8800 	pop	{fp, pc}
   10804:	000111d8 	.word	0x000111d8
   10808:	0001114c 	.word	0x0001114c
   1080c:	00011160 	.word	0x00011160
   10810:	00011170 	.word	0x00011170
   10814:	00011180 	.word	0x00011180
   10818:	00011198 	.word	0x00011198
   1081c:	000111b0 	.word	0x000111b0
   10820:	000111e4 	.word	0x000111e4

00010824 <reverse_debug>:

struct list * reverse_debug(struct list * node)
{
   10824:	e92d4800 	push	{fp, lr}
   10828:	e28db004 	add	fp, sp, #4
   1082c:	e24dd020 	sub	sp, sp, #32
   10830:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
  struct list * src, * des, * tmp;

  tmp = node;
   10834:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10838:	e50b300c 	str	r3, [fp, #-12]
  printf("node:%p\n", node);
   1083c:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10840:	e59f0278 	ldr	r0, [pc, #632]	; 10ac0 <reverse_debug+0x29c>
   10844:	ebfffece 	bl	10384 <printf@plt>
  while(tmp != NULL) {
   10848:	ea000005 	b	10864 <reverse_debug+0x40>
    printf(" [[%p]] ", tmp);
   1084c:	e51b100c 	ldr	r1, [fp, #-12]
   10850:	e59f026c 	ldr	r0, [pc, #620]	; 10ac4 <reverse_debug+0x2a0>
   10854:	ebfffeca 	bl	10384 <printf@plt>
    tmp = tmp->next;
   10858:	e51b300c 	ldr	r3, [fp, #-12]
   1085c:	e5933004 	ldr	r3, [r3, #4]
   10860:	e50b300c 	str	r3, [fp, #-12]
{
  struct list * src, * des, * tmp;

  tmp = node;
  printf("node:%p\n", node);
  while(tmp != NULL) {
   10864:	e51b300c 	ldr	r3, [fp, #-12]
   10868:	e3530000 	cmp	r3, #0
   1086c:	1afffff6 	bne	1084c <reverse_debug+0x28>
    printf(" [[%p]] ", tmp);
    tmp = tmp->next;
  }
  printf("\n");
   10870:	e3a0000a 	mov	r0, #10
   10874:	ebfffebf 	bl	10378 <putchar@plt>
  printf("%p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
   10878:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1087c:	e5931004 	ldr	r1, [r3, #4]
   10880:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10884:	e5933004 	ldr	r3, [r3, #4]
   10888:	e5930004 	ldr	r0, [r3, #4]
   1088c:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10890:	e5933004 	ldr	r3, [r3, #4]
   10894:	e5933004 	ldr	r3, [r3, #4]
   10898:	e5933004 	ldr	r3, [r3, #4]
   1089c:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   108a0:	e5922004 	ldr	r2, [r2, #4]
   108a4:	e5922004 	ldr	r2, [r2, #4]
   108a8:	e5922004 	ldr	r2, [r2, #4]
   108ac:	e5922004 	ldr	r2, [r2, #4]
   108b0:	e58d2004 	str	r2, [sp, #4]
   108b4:	e58d3000 	str	r3, [sp]
   108b8:	e1a03000 	mov	r3, r0
   108bc:	e1a02001 	mov	r2, r1
   108c0:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   108c4:	e59f01fc 	ldr	r0, [pc, #508]	; 10ac8 <reverse_debug+0x2a4>
   108c8:	ebfffead 	bl	10384 <printf@plt>
  printf("%d:%11d:%11d:%11d:%11d\n", node->num, node->next->num, node->next->next->num, node->next->next->next->num, 
   108cc:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   108d0:	e5931000 	ldr	r1, [r3]
   108d4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   108d8:	e5933004 	ldr	r3, [r3, #4]
   108dc:	e5930000 	ldr	r0, [r3]
   108e0:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   108e4:	e5933004 	ldr	r3, [r3, #4]
   108e8:	e5933004 	ldr	r3, [r3, #4]
   108ec:	e593c000 	ldr	ip, [r3]
   108f0:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   108f4:	e5933004 	ldr	r3, [r3, #4]
   108f8:	e5933004 	ldr	r3, [r3, #4]
   108fc:	e5933004 	ldr	r3, [r3, #4]
   10900:	e5933000 	ldr	r3, [r3]
	 node->next->next->next->next->num);
   10904:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   10908:	e5922004 	ldr	r2, [r2, #4]
   1090c:	e5922004 	ldr	r2, [r2, #4]
   10910:	e5922004 	ldr	r2, [r2, #4]
   10914:	e5922004 	ldr	r2, [r2, #4]
    printf(" [[%p]] ", tmp);
    tmp = tmp->next;
  }
  printf("\n");
  printf("%p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next);
  printf("%d:%11d:%11d:%11d:%11d\n", node->num, node->next->num, node->next->next->num, node->next->next->next->num, 
   10918:	e5922000 	ldr	r2, [r2]
   1091c:	e58d2004 	str	r2, [sp, #4]
   10920:	e58d3000 	str	r3, [sp]
   10924:	e1a0300c 	mov	r3, ip
   10928:	e1a02000 	mov	r2, r0
   1092c:	e59f0198 	ldr	r0, [pc, #408]	; 10acc <reverse_debug+0x2a8>
   10930:	ebfffe93 	bl	10384 <printf@plt>
	 node->next->next->next->next->num);

  src = node->next;  // 指向第二个数据节点
   10934:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10938:	e5933004 	ldr	r3, [r3, #4]
   1093c:	e50b3008 	str	r3, [fp, #-8]
  printf(" src=node->next:[%p:%d] [%p:%d]\n", src, src->num, node->next, node->next->num); 
   10940:	e51b3008 	ldr	r3, [fp, #-8]
   10944:	e5932000 	ldr	r2, [r3]
   10948:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   1094c:	e5931004 	ldr	r1, [r3, #4]
   10950:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10954:	e5933004 	ldr	r3, [r3, #4]
   10958:	e5933000 	ldr	r3, [r3]
   1095c:	e58d3000 	str	r3, [sp]
   10960:	e1a03001 	mov	r3, r1
   10964:	e51b1008 	ldr	r1, [fp, #-8]
   10968:	e59f0160 	ldr	r0, [pc, #352]	; 10ad0 <reverse_debug+0x2ac>
   1096c:	ebfffe84 	bl	10384 <printf@plt>
  node->next = NULL; // 将原链表置为空
   10970:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10974:	e3a02000 	mov	r2, #0
   10978:	e5832004 	str	r2, [r3, #4]
  printf(" node->next=NULL [%p:%d]\n\n ", node->next, node->num); 
   1097c:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10980:	e5931004 	ldr	r1, [r3, #4]
   10984:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10988:	e5933000 	ldr	r3, [r3]
   1098c:	e1a02003 	mov	r2, r3
   10990:	e59f013c 	ldr	r0, [pc, #316]	; 10ad4 <reverse_debug+0x2b0>
   10994:	ebfffe7a 	bl	10384 <printf@plt>
  
  while (src) {
   10998:	ea00003e 	b	10a98 <reverse_debug+0x274>
    printf(" while->src=[%p:%d] \n", src,  src->num); 
   1099c:	e51b3008 	ldr	r3, [fp, #-8]
   109a0:	e5933000 	ldr	r3, [r3]
   109a4:	e1a02003 	mov	r2, r3
   109a8:	e51b1008 	ldr	r1, [fp, #-8]
   109ac:	e59f0124 	ldr	r0, [pc, #292]	; 10ad8 <reverse_debug+0x2b4>
   109b0:	ebfffe73 	bl	10384 <printf@plt>
    des = src;
   109b4:	e51b3008 	ldr	r3, [fp, #-8]
   109b8:	e50b3010 	str	r3, [fp, #-16]
    printf(" des=src des:[%p:%d] src:[%p:%d]\n", des, des->num, src, src->num);
   109bc:	e51b3010 	ldr	r3, [fp, #-16]
   109c0:	e5932000 	ldr	r2, [r3]
   109c4:	e51b3008 	ldr	r3, [fp, #-8]
   109c8:	e5933000 	ldr	r3, [r3]
   109cc:	e58d3000 	str	r3, [sp]
   109d0:	e51b3008 	ldr	r3, [fp, #-8]
   109d4:	e51b1010 	ldr	r1, [fp, #-16]
   109d8:	e59f00fc 	ldr	r0, [pc, #252]	; 10adc <reverse_debug+0x2b8>
   109dc:	ebfffe68 	bl	10384 <printf@plt>
    src = src->next;
   109e0:	e51b3008 	ldr	r3, [fp, #-8]
   109e4:	e5933004 	ldr	r3, [r3, #4]
   109e8:	e50b3008 	str	r3, [fp, #-8]
    printf(" src=src->next[%p]", src);
   109ec:	e51b1008 	ldr	r1, [fp, #-8]
   109f0:	e59f00e8 	ldr	r0, [pc, #232]	; 10ae0 <reverse_debug+0x2bc>
   109f4:	ebfffe62 	bl	10384 <printf@plt>
    if (src != NULL)
   109f8:	e51b3008 	ldr	r3, [fp, #-8]
   109fc:	e3530000 	cmp	r3, #0
   10a00:	0a000005 	beq	10a1c <reverse_debug+0x1f8>
      printf(":[%d]\n", src->num);
   10a04:	e51b3008 	ldr	r3, [fp, #-8]
   10a08:	e5933000 	ldr	r3, [r3]
   10a0c:	e1a01003 	mov	r1, r3
   10a10:	e59f00cc 	ldr	r0, [pc, #204]	; 10ae4 <reverse_debug+0x2c0>
   10a14:	ebfffe5a 	bl	10384 <printf@plt>
   10a18:	ea000001 	b	10a24 <reverse_debug+0x200>
    else
      printf("[blank]\n");
   10a1c:	e59f00c4 	ldr	r0, [pc, #196]	; 10ae8 <reverse_debug+0x2c4>
   10a20:	ebfffe5a 	bl	10390 <puts@plt>
    des->next = node->next; // 将当前节点插到头节点的后面
   10a24:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10a28:	e5932004 	ldr	r2, [r3, #4]
   10a2c:	e51b3010 	ldr	r3, [fp, #-16]
   10a30:	e5832004 	str	r2, [r3, #4]
    printf(" des->next=node->next [%p:%d]%p\n", des->next, des->num, node->next);
   10a34:	e51b3010 	ldr	r3, [fp, #-16]
   10a38:	e5931004 	ldr	r1, [r3, #4]
   10a3c:	e51b3010 	ldr	r3, [fp, #-16]
   10a40:	e5932000 	ldr	r2, [r3]
   10a44:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10a48:	e5933004 	ldr	r3, [r3, #4]
   10a4c:	e59f0098 	ldr	r0, [pc, #152]	; 10aec <reverse_debug+0x2c8>
   10a50:	ebfffe4b 	bl	10384 <printf@plt>
    node->next = des;
   10a54:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10a58:	e51b2010 	ldr	r2, [fp, #-16]
   10a5c:	e5832004 	str	r2, [r3, #4]
    printf(" node->next=des [%p:%d]<=>[%p:%d]\n", node->next, node->next->num, des, des->num);
   10a60:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10a64:	e5931004 	ldr	r1, [r3, #4]
   10a68:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10a6c:	e5933004 	ldr	r3, [r3, #4]
   10a70:	e5932000 	ldr	r2, [r3]
   10a74:	e51b3010 	ldr	r3, [fp, #-16]
   10a78:	e5933000 	ldr	r3, [r3]
   10a7c:	e58d3000 	str	r3, [sp]
   10a80:	e51b3010 	ldr	r3, [fp, #-16]
   10a84:	e59f0064 	ldr	r0, [pc, #100]	; 10af0 <reverse_debug+0x2cc>
   10a88:	ebfffe3d 	bl	10384 <printf@plt>
    printf("while once end node:[%p] \n\n", node);
   10a8c:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10a90:	e59f005c 	ldr	r0, [pc, #92]	; 10af4 <reverse_debug+0x2d0>
   10a94:	ebfffe3a 	bl	10384 <printf@plt>
  src = node->next;  // 指向第二个数据节点
  printf(" src=node->next:[%p:%d] [%p:%d]\n", src, src->num, node->next, node->next->num); 
  node->next = NULL; // 将原链表置为空
  printf(" node->next=NULL [%p:%d]\n\n ", node->next, node->num); 
  
  while (src) {
   10a98:	e51b3008 	ldr	r3, [fp, #-8]
   10a9c:	e3530000 	cmp	r3, #0
   10aa0:	1affffbd 	bne	1099c <reverse_debug+0x178>
    node->next = des;
    printf(" node->next=des [%p:%d]<=>[%p:%d]\n", node->next, node->next->num, des, des->num);
    printf("while once end node:[%p] \n\n", node);
  }
  
  printf("return node : [%p]\n\n", node);
   10aa4:	e51b1018 	ldr	r1, [fp, #-24]	; 0xffffffe8
   10aa8:	e59f0048 	ldr	r0, [pc, #72]	; 10af8 <reverse_debug+0x2d4>
   10aac:	ebfffe34 	bl	10384 <printf@plt>

  return node;
   10ab0:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
}
   10ab4:	e1a00003 	mov	r0, r3
   10ab8:	e24bd004 	sub	sp, fp, #4
   10abc:	e8bd8800 	pop	{fp, pc}
   10ac0:	00011208 	.word	0x00011208
   10ac4:	00011214 	.word	0x00011214
   10ac8:	00011220 	.word	0x00011220
   10acc:	00011234 	.word	0x00011234
   10ad0:	0001124c 	.word	0x0001124c
   10ad4:	00011270 	.word	0x00011270
   10ad8:	0001128c 	.word	0x0001128c
   10adc:	000112a4 	.word	0x000112a4
   10ae0:	000112c8 	.word	0x000112c8
   10ae4:	000112dc 	.word	0x000112dc
   10ae8:	000112e4 	.word	0x000112e4
   10aec:	000112ec 	.word	0x000112ec
   10af0:	00011310 	.word	0x00011310
   10af4:	00011334 	.word	0x00011334
   10af8:	00011350 	.word	0x00011350

00010afc <reverse_1>:


struct list * reverse_1(struct list * node)
{
   10afc:	e92d4800 	push	{fp, lr}
   10b00:	e28db004 	add	fp, sp, #4
   10b04:	e24dd020 	sub	sp, sp, #32
   10b08:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  printf("%p: %p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next,
   10b0c:	e51b3010 	ldr	r3, [fp, #-16]
   10b10:	e5930004 	ldr	r0, [r3, #4]
   10b14:	e51b3010 	ldr	r3, [fp, #-16]
   10b18:	e5933004 	ldr	r3, [r3, #4]
   10b1c:	e593c004 	ldr	ip, [r3, #4]
   10b20:	e51b3010 	ldr	r3, [fp, #-16]
   10b24:	e5933004 	ldr	r3, [r3, #4]
   10b28:	e5933004 	ldr	r3, [r3, #4]
   10b2c:	e5933004 	ldr	r3, [r3, #4]
   10b30:	e51b2010 	ldr	r2, [fp, #-16]
   10b34:	e5922004 	ldr	r2, [r2, #4]
   10b38:	e5922004 	ldr	r2, [r2, #4]
   10b3c:	e5922004 	ldr	r2, [r2, #4]
   10b40:	e5922004 	ldr	r2, [r2, #4]
	 node->next->next->next->next->next);
   10b44:	e51b1010 	ldr	r1, [fp, #-16]
   10b48:	e5911004 	ldr	r1, [r1, #4]
   10b4c:	e5911004 	ldr	r1, [r1, #4]
   10b50:	e5911004 	ldr	r1, [r1, #4]
   10b54:	e5911004 	ldr	r1, [r1, #4]

struct list * reverse_1(struct list * node)
{
  struct list * src, * des;

  printf("%p: %p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next,
   10b58:	e5911004 	ldr	r1, [r1, #4]
   10b5c:	e58d1008 	str	r1, [sp, #8]
   10b60:	e58d2004 	str	r2, [sp, #4]
   10b64:	e58d3000 	str	r3, [sp]
   10b68:	e1a0300c 	mov	r3, ip
   10b6c:	e1a02000 	mov	r2, r0
   10b70:	e51b1010 	ldr	r1, [fp, #-16]
   10b74:	e59f00f4 	ldr	r0, [pc, #244]	; 10c70 <reverse_1+0x174>
   10b78:	ebfffe01 	bl	10384 <printf@plt>
	 node->next->next->next->next->next);
  src = node->next;
   10b7c:	e51b3010 	ldr	r3, [fp, #-16]
   10b80:	e5933004 	ldr	r3, [r3, #4]
   10b84:	e50b3008 	str	r3, [fp, #-8]
  printf("src = node->next  %p:%p\n\n", src, node->next);
   10b88:	e51b3010 	ldr	r3, [fp, #-16]
   10b8c:	e5933004 	ldr	r3, [r3, #4]
   10b90:	e1a02003 	mov	r2, r3
   10b94:	e51b1008 	ldr	r1, [fp, #-8]
   10b98:	e59f00d4 	ldr	r0, [pc, #212]	; 10c74 <reverse_1+0x178>
   10b9c:	ebfffdf8 	bl	10384 <printf@plt>
  while (src->next != NULL) {
   10ba0:	ea000027 	b	10c44 <reverse_1+0x148>
    des = src->next;
   10ba4:	e51b3008 	ldr	r3, [fp, #-8]
   10ba8:	e5933004 	ldr	r3, [r3, #4]
   10bac:	e50b300c 	str	r3, [fp, #-12]
    printf("des = src->next  %p:%p\n", des, src->next);
   10bb0:	e51b3008 	ldr	r3, [fp, #-8]
   10bb4:	e5933004 	ldr	r3, [r3, #4]
   10bb8:	e1a02003 	mov	r2, r3
   10bbc:	e51b100c 	ldr	r1, [fp, #-12]
   10bc0:	e59f00b0 	ldr	r0, [pc, #176]	; 10c78 <reverse_1+0x17c>
   10bc4:	ebfffdee 	bl	10384 <printf@plt>
    src->next = des->next;
   10bc8:	e51b300c 	ldr	r3, [fp, #-12]
   10bcc:	e5932004 	ldr	r2, [r3, #4]
   10bd0:	e51b3008 	ldr	r3, [fp, #-8]
   10bd4:	e5832004 	str	r2, [r3, #4]
    printf("src->next = des->next  %p:%p\n", src->next, des->next);
   10bd8:	e51b3008 	ldr	r3, [fp, #-8]
   10bdc:	e5931004 	ldr	r1, [r3, #4]
   10be0:	e51b300c 	ldr	r3, [fp, #-12]
   10be4:	e5933004 	ldr	r3, [r3, #4]
   10be8:	e1a02003 	mov	r2, r3
   10bec:	e59f0088 	ldr	r0, [pc, #136]	; 10c7c <reverse_1+0x180>
   10bf0:	ebfffde3 	bl	10384 <printf@plt>
    des->next = node->next;
   10bf4:	e51b3010 	ldr	r3, [fp, #-16]
   10bf8:	e5932004 	ldr	r2, [r3, #4]
   10bfc:	e51b300c 	ldr	r3, [fp, #-12]
   10c00:	e5832004 	str	r2, [r3, #4]
    printf("des->next = node->next  %p:%p\n", des->next, node->next);
   10c04:	e51b300c 	ldr	r3, [fp, #-12]
   10c08:	e5931004 	ldr	r1, [r3, #4]
   10c0c:	e51b3010 	ldr	r3, [fp, #-16]
   10c10:	e5933004 	ldr	r3, [r3, #4]
   10c14:	e1a02003 	mov	r2, r3
   10c18:	e59f0060 	ldr	r0, [pc, #96]	; 10c80 <reverse_1+0x184>
   10c1c:	ebfffdd8 	bl	10384 <printf@plt>
    node->next = des;
   10c20:	e51b3010 	ldr	r3, [fp, #-16]
   10c24:	e51b200c 	ldr	r2, [fp, #-12]
   10c28:	e5832004 	str	r2, [r3, #4]
    printf("node->next = des  %p:%p\n\n", node->next, des);
   10c2c:	e51b3010 	ldr	r3, [fp, #-16]
   10c30:	e5933004 	ldr	r3, [r3, #4]
   10c34:	e51b200c 	ldr	r2, [fp, #-12]
   10c38:	e1a01003 	mov	r1, r3
   10c3c:	e59f0040 	ldr	r0, [pc, #64]	; 10c84 <reverse_1+0x188>
   10c40:	ebfffdcf 	bl	10384 <printf@plt>

  printf("%p: %p: %p: %p: %p: %p\n", node, node->next, node->next->next, node->next->next->next, node->next->next->next->next,
	 node->next->next->next->next->next);
  src = node->next;
  printf("src = node->next  %p:%p\n\n", src, node->next);
  while (src->next != NULL) {
   10c44:	e51b3008 	ldr	r3, [fp, #-8]
   10c48:	e5933004 	ldr	r3, [r3, #4]
   10c4c:	e3530000 	cmp	r3, #0
   10c50:	1affffd3 	bne	10ba4 <reverse_1+0xa8>
    des->next = node->next;
    printf("des->next = node->next  %p:%p\n", des->next, node->next);
    node->next = des;
    printf("node->next = des  %p:%p\n\n", node->next, des);
  }
  printf("reverse_1 end of node %p\n", node);
   10c54:	e51b1010 	ldr	r1, [fp, #-16]
   10c58:	e59f0028 	ldr	r0, [pc, #40]	; 10c88 <reverse_1+0x18c>
   10c5c:	ebfffdc8 	bl	10384 <printf@plt>

  return node;
   10c60:	e51b3010 	ldr	r3, [fp, #-16]
}
   10c64:	e1a00003 	mov	r0, r3
   10c68:	e24bd004 	sub	sp, fp, #4
   10c6c:	e8bd8800 	pop	{fp, pc}
   10c70:	00011368 	.word	0x00011368
   10c74:	00011380 	.word	0x00011380
   10c78:	0001139c 	.word	0x0001139c
   10c7c:	000113b4 	.word	0x000113b4
   10c80:	000113d4 	.word	0x000113d4
   10c84:	000113f4 	.word	0x000113f4
   10c88:	00011410 	.word	0x00011410

00010c8c <reverse_2>:

struct list * reverse_2(struct list * node)
{
   10c8c:	e92d4800 	push	{fp, lr}
   10c90:	e28db004 	add	fp, sp, #4
   10c94:	e24dd018 	sub	sp, sp, #24
   10c98:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
  struct list * src, * pnext, * prev;

  src = node->next;
   10c9c:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10ca0:	e5933004 	ldr	r3, [r3, #4]
   10ca4:	e50b3008 	str	r3, [fp, #-8]
  printf("src = node->next %p:%p\n", src, node->next);
   10ca8:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10cac:	e5933004 	ldr	r3, [r3, #4]
   10cb0:	e1a02003 	mov	r2, r3
   10cb4:	e51b1008 	ldr	r1, [fp, #-8]
   10cb8:	e59f010c 	ldr	r0, [pc, #268]	; 10dcc <reverse_2+0x140>
   10cbc:	ebfffdb0 	bl	10384 <printf@plt>
  pnext = src->next;
   10cc0:	e51b3008 	ldr	r3, [fp, #-8]
   10cc4:	e5933004 	ldr	r3, [r3, #4]
   10cc8:	e50b300c 	str	r3, [fp, #-12]
  printf("pnext = src->next %p:%p\n", pnext, src->next);
   10ccc:	e51b3008 	ldr	r3, [fp, #-8]
   10cd0:	e5933004 	ldr	r3, [r3, #4]
   10cd4:	e1a02003 	mov	r2, r3
   10cd8:	e51b100c 	ldr	r1, [fp, #-12]
   10cdc:	e59f00ec 	ldr	r0, [pc, #236]	; 10dd0 <reverse_2+0x144>
   10ce0:	ebfffda7 	bl	10384 <printf@plt>
  src->next = NULL;
   10ce4:	e51b3008 	ldr	r3, [fp, #-8]
   10ce8:	e3a02000 	mov	r2, #0
   10cec:	e5832004 	str	r2, [r3, #4]
  printf("src->next = NULL %p\n\n", src->next);
   10cf0:	e51b3008 	ldr	r3, [fp, #-8]
   10cf4:	e5933004 	ldr	r3, [r3, #4]
   10cf8:	e1a01003 	mov	r1, r3
   10cfc:	e59f00d0 	ldr	r0, [pc, #208]	; 10dd4 <reverse_2+0x148>
   10d00:	ebfffd9f 	bl	10384 <printf@plt>
  while (pnext) {
   10d04:	ea000020 	b	10d8c <reverse_2+0x100>
    printf("pnext %p \n", pnext);
   10d08:	e51b100c 	ldr	r1, [fp, #-12]
   10d0c:	e59f00c4 	ldr	r0, [pc, #196]	; 10dd8 <reverse_2+0x14c>
   10d10:	ebfffd9b 	bl	10384 <printf@plt>
    prev = pnext->next;
   10d14:	e51b300c 	ldr	r3, [fp, #-12]
   10d18:	e5933004 	ldr	r3, [r3, #4]
   10d1c:	e50b3010 	str	r3, [fp, #-16]
    printf("prev = pnext->next %p:%p\n", prev, pnext->next);
   10d20:	e51b300c 	ldr	r3, [fp, #-12]
   10d24:	e5933004 	ldr	r3, [r3, #4]
   10d28:	e1a02003 	mov	r2, r3
   10d2c:	e51b1010 	ldr	r1, [fp, #-16]
   10d30:	e59f00a4 	ldr	r0, [pc, #164]	; 10ddc <reverse_2+0x150>
   10d34:	ebfffd92 	bl	10384 <printf@plt>
    pnext->next = src;
   10d38:	e51b300c 	ldr	r3, [fp, #-12]
   10d3c:	e51b2008 	ldr	r2, [fp, #-8]
   10d40:	e5832004 	str	r2, [r3, #4]
    printf("pnext->next = src %p:%p\n", pnext->next, src);
   10d44:	e51b300c 	ldr	r3, [fp, #-12]
   10d48:	e5933004 	ldr	r3, [r3, #4]
   10d4c:	e51b2008 	ldr	r2, [fp, #-8]
   10d50:	e1a01003 	mov	r1, r3
   10d54:	e59f0084 	ldr	r0, [pc, #132]	; 10de0 <reverse_2+0x154>
   10d58:	ebfffd89 	bl	10384 <printf@plt>
    src = pnext;
   10d5c:	e51b300c 	ldr	r3, [fp, #-12]
   10d60:	e50b3008 	str	r3, [fp, #-8]
    printf("src = pnext %p:%p\n", src, pnext);
   10d64:	e51b200c 	ldr	r2, [fp, #-12]
   10d68:	e51b1008 	ldr	r1, [fp, #-8]
   10d6c:	e59f0070 	ldr	r0, [pc, #112]	; 10de4 <reverse_2+0x158>
   10d70:	ebfffd83 	bl	10384 <printf@plt>
    pnext = prev;
   10d74:	e51b3010 	ldr	r3, [fp, #-16]
   10d78:	e50b300c 	str	r3, [fp, #-12]
    printf("pnext = prev %p:%p\n\n", pnext, prev);
   10d7c:	e51b2010 	ldr	r2, [fp, #-16]
   10d80:	e51b100c 	ldr	r1, [fp, #-12]
   10d84:	e59f005c 	ldr	r0, [pc, #92]	; 10de8 <reverse_2+0x15c>
   10d88:	ebfffd7d 	bl	10384 <printf@plt>
  printf("src = node->next %p:%p\n", src, node->next);
  pnext = src->next;
  printf("pnext = src->next %p:%p\n", pnext, src->next);
  src->next = NULL;
  printf("src->next = NULL %p\n\n", src->next);
  while (pnext) {
   10d8c:	e51b300c 	ldr	r3, [fp, #-12]
   10d90:	e3530000 	cmp	r3, #0
   10d94:	1affffdb 	bne	10d08 <reverse_2+0x7c>
    src = pnext;
    printf("src = pnext %p:%p\n", src, pnext);
    pnext = prev;
    printf("pnext = prev %p:%p\n\n", pnext, prev);
  }
  node->next = src;
   10d98:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10d9c:	e51b2008 	ldr	r2, [fp, #-8]
   10da0:	e5832004 	str	r2, [r3, #4]
  printf("node->next = src %p:%p\n\n", node->next, src);
   10da4:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10da8:	e5933004 	ldr	r3, [r3, #4]
   10dac:	e51b2008 	ldr	r2, [fp, #-8]
   10db0:	e1a01003 	mov	r1, r3
   10db4:	e59f0030 	ldr	r0, [pc, #48]	; 10dec <reverse_2+0x160>
   10db8:	ebfffd71 	bl	10384 <printf@plt>

  return node;
   10dbc:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
}
   10dc0:	e1a00003 	mov	r0, r3
   10dc4:	e24bd004 	sub	sp, fp, #4
   10dc8:	e8bd8800 	pop	{fp, pc}
   10dcc:	0001142c 	.word	0x0001142c
   10dd0:	00011444 	.word	0x00011444
   10dd4:	00011460 	.word	0x00011460
   10dd8:	00011478 	.word	0x00011478
   10ddc:	00011484 	.word	0x00011484
   10de0:	000114a0 	.word	0x000114a0
   10de4:	000114bc 	.word	0x000114bc
   10de8:	000114d0 	.word	0x000114d0
   10dec:	000114e8 	.word	0x000114e8

00010df0 <merge_debug>:

struct list * merge_debug(struct list * first, struct list * second)
{
   10df0:	e92d4800 	push	{fp, lr}
   10df4:	e28db004 	add	fp, sp, #4
   10df8:	e24dd010 	sub	sp, sp, #16
   10dfc:	e50b0010 	str	r0, [fp, #-16]
   10e00:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;

  src = first;
   10e04:	e51b3010 	ldr	r3, [fp, #-16]
   10e08:	e50b3008 	str	r3, [fp, #-8]
  printf("src first second %p:%p:%p\n\n", src, first, second);
   10e0c:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10e10:	e51b2010 	ldr	r2, [fp, #-16]
   10e14:	e51b1008 	ldr	r1, [fp, #-8]
   10e18:	e59f007c 	ldr	r0, [pc, #124]	; 10e9c <merge_debug+0xac>
   10e1c:	ebfffd58 	bl	10384 <printf@plt>
  while (src->next) { // 改为 src, 循环多一次，地址会跑飞，因而链不起来
   10e20:	ea00000b 	b	10e54 <merge_debug+0x64>
    printf("while src src->next %p:%p \n", src, src->next);
   10e24:	e51b3008 	ldr	r3, [fp, #-8]
   10e28:	e5933004 	ldr	r3, [r3, #4]
   10e2c:	e1a02003 	mov	r2, r3
   10e30:	e51b1008 	ldr	r1, [fp, #-8]
   10e34:	e59f0064 	ldr	r0, [pc, #100]	; 10ea0 <merge_debug+0xb0>
   10e38:	ebfffd51 	bl	10384 <printf@plt>
    src = src->next;
   10e3c:	e51b3008 	ldr	r3, [fp, #-8]
   10e40:	e5933004 	ldr	r3, [r3, #4]
   10e44:	e50b3008 	str	r3, [fp, #-8]
    printf("src = src->next  %p \n\n", src);
   10e48:	e51b1008 	ldr	r1, [fp, #-8]
   10e4c:	e59f0050 	ldr	r0, [pc, #80]	; 10ea4 <merge_debug+0xb4>
   10e50:	ebfffd4b 	bl	10384 <printf@plt>
{
  struct list * src;

  src = first;
  printf("src first second %p:%p:%p\n\n", src, first, second);
  while (src->next) { // 改为 src, 循环多一次，地址会跑飞，因而链不起来
   10e54:	e51b3008 	ldr	r3, [fp, #-8]
   10e58:	e5933004 	ldr	r3, [r3, #4]
   10e5c:	e3530000 	cmp	r3, #0
   10e60:	1affffef 	bne	10e24 <merge_debug+0x34>
    printf("while src src->next %p:%p \n", src, src->next);
    src = src->next;
    printf("src = src->next  %p \n\n", src);
  }
  printf("end whiel src %p \n", src);
   10e64:	e51b1008 	ldr	r1, [fp, #-8]
   10e68:	e59f0038 	ldr	r0, [pc, #56]	; 10ea8 <merge_debug+0xb8>
   10e6c:	ebfffd44 	bl	10384 <printf@plt>
  src->next = second;
   10e70:	e51b3008 	ldr	r3, [fp, #-8]
   10e74:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   10e78:	e5832004 	str	r2, [r3, #4]
  printf("src first %p:%p\n", src, first);
   10e7c:	e51b2010 	ldr	r2, [fp, #-16]
   10e80:	e51b1008 	ldr	r1, [fp, #-8]
   10e84:	e59f0020 	ldr	r0, [pc, #32]	; 10eac <merge_debug+0xbc>
   10e88:	ebfffd3d 	bl	10384 <printf@plt>

  return first;
   10e8c:	e51b3010 	ldr	r3, [fp, #-16]
}
   10e90:	e1a00003 	mov	r0, r3
   10e94:	e24bd004 	sub	sp, fp, #4
   10e98:	e8bd8800 	pop	{fp, pc}
   10e9c:	00011504 	.word	0x00011504
   10ea0:	00011520 	.word	0x00011520
   10ea4:	0001153c 	.word	0x0001153c
   10ea8:	00011554 	.word	0x00011554
   10eac:	00011568 	.word	0x00011568

00010eb0 <create_circular_link>:
#include <string.h>
#include "list.h"

/* create a circular linked list */
struct list * create_circular_link()
{
   10eb0:	e92d4800 	push	{fp, lr}
   10eb4:	e28db004 	add	fp, sp, #4
   10eb8:	e24dd008 	sub	sp, sp, #8
  struct list * new;

  new = (struct list *) malloc (sizeof(struct list));
   10ebc:	e3a00008 	mov	r0, #8
   10ec0:	ebfffd35 	bl	1039c <malloc@plt>
   10ec4:	e1a03000 	mov	r3, r0
   10ec8:	e50b3008 	str	r3, [fp, #-8]
  if (!new) {
   10ecc:	e51b3008 	ldr	r3, [fp, #-8]
   10ed0:	e3530000 	cmp	r3, #0
   10ed4:	1a000003 	bne	10ee8 <create_circular_link+0x38>
    printf("cannot create a list");
   10ed8:	e59f0054 	ldr	r0, [pc, #84]	; 10f34 <create_circular_link+0x84>
   10edc:	ebfffd28 	bl	10384 <printf@plt>
    return NULL;
   10ee0:	e3a03000 	mov	r3, #0
   10ee4:	ea00000f 	b	10f28 <create_circular_link+0x78>
  }
  printf(" news %p \n", new);
   10ee8:	e51b1008 	ldr	r1, [fp, #-8]
   10eec:	e59f0044 	ldr	r0, [pc, #68]	; 10f38 <create_circular_link+0x88>
   10ef0:	ebfffd23 	bl	10384 <printf@plt>

  new->num = 0;
   10ef4:	e51b3008 	ldr	r3, [fp, #-8]
   10ef8:	e3a02000 	mov	r2, #0
   10efc:	e5832000 	str	r2, [r3]
  new->next = new;	// circular
   10f00:	e51b3008 	ldr	r3, [fp, #-8]
   10f04:	e51b2008 	ldr	r2, [fp, #-8]
   10f08:	e5832004 	str	r2, [r3, #4]
  printf("new->next = new %p:%p\n", new->next, new);
   10f0c:	e51b3008 	ldr	r3, [fp, #-8]
   10f10:	e5933004 	ldr	r3, [r3, #4]
   10f14:	e51b2008 	ldr	r2, [fp, #-8]
   10f18:	e1a01003 	mov	r1, r3
   10f1c:	e59f0018 	ldr	r0, [pc, #24]	; 10f3c <create_circular_link+0x8c>
   10f20:	ebfffd17 	bl	10384 <printf@plt>

  return new;
   10f24:	e51b3008 	ldr	r3, [fp, #-8]
}
   10f28:	e1a00003 	mov	r0, r3
   10f2c:	e24bd004 	sub	sp, fp, #4
   10f30:	e8bd8800 	pop	{fp, pc}
   10f34:	0001157c 	.word	0x0001157c
   10f38:	00011594 	.word	0x00011594
   10f3c:	000115a0 	.word	0x000115a0

00010f40 <insert>:

/* insert a new node */
struct list * insert(struct list * node, int data)
{
   10f40:	e92d4800 	push	{fp, lr}
   10f44:	e28db004 	add	fp, sp, #4
   10f48:	e24dd020 	sub	sp, sp, #32
   10f4c:	e50b0020 	str	r0, [fp, #-32]	; 0xffffffe0
   10f50:	e50b1024 	str	r1, [fp, #-36]	; 0xffffffdc
  struct list * head, * new, * src, * des;
  int i = 0;
   10f54:	e3a03000 	mov	r3, #0
   10f58:	e50b3010 	str	r3, [fp, #-16]

  head = node; 
   10f5c:	e51b3020 	ldr	r3, [fp, #-32]	; 0xffffffe0
   10f60:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
  src = node;
   10f64:	e51b3020 	ldr	r3, [fp, #-32]	; 0xffffffe0
   10f68:	e50b3008 	str	r3, [fp, #-8]
  des = head->next; 
   10f6c:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10f70:	e5933004 	ldr	r3, [r3, #4]
   10f74:	e50b300c 	str	r3, [fp, #-12]

  while(des != head) {	// 找到最后一个节点
   10f78:	ea000008 	b	10fa0 <insert+0x60>
    src = des;		// 指向后一个节点
   10f7c:	e51b300c 	ldr	r3, [fp, #-12]
   10f80:	e50b3008 	str	r3, [fp, #-8]
    des = des->next; 
   10f84:	e51b300c 	ldr	r3, [fp, #-12]
   10f88:	e5933004 	ldr	r3, [r3, #4]
   10f8c:	e50b300c 	str	r3, [fp, #-12]
    printf("while src des %p:%p \n", src, des);
   10f90:	e51b200c 	ldr	r2, [fp, #-12]
   10f94:	e51b1008 	ldr	r1, [fp, #-8]
   10f98:	e59f008c 	ldr	r0, [pc, #140]	; 1102c <insert+0xec>
   10f9c:	ebfffcf8 	bl	10384 <printf@plt>

  head = node; 
  src = node;
  des = head->next; 

  while(des != head) {	// 找到最后一个节点
   10fa0:	e51b200c 	ldr	r2, [fp, #-12]
   10fa4:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10fa8:	e1520003 	cmp	r2, r3
   10fac:	1afffff2 	bne	10f7c <insert+0x3c>
    src = des;		// 指向后一个节点
    des = des->next; 
    printf("while src des %p:%p \n", src, des);
  }

  new = (struct list *)malloc(sizeof(struct list));
   10fb0:	e3a00008 	mov	r0, #8
   10fb4:	ebfffcf8 	bl	1039c <malloc@plt>
   10fb8:	e1a03000 	mov	r3, r0
   10fbc:	e50b3018 	str	r3, [fp, #-24]	; 0xffffffe8
  if(!new){
   10fc0:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10fc4:	e3530000 	cmp	r3, #0
   10fc8:	1a000003 	bne	10fdc <insert+0x9c>
    printf("TailInsert:cannot create a list");
   10fcc:	e59f005c 	ldr	r0, [pc, #92]	; 11030 <insert+0xf0>
   10fd0:	ebfffceb 	bl	10384 <printf@plt>
    return NULL;
   10fd4:	e3a03000 	mov	r3, #0
   10fd8:	ea000010 	b	11020 <insert+0xe0>
  }
  new->num = data; 
   10fdc:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10fe0:	e51b2024 	ldr	r2, [fp, #-36]	; 0xffffffdc
   10fe4:	e5832000 	str	r2, [r3]
  new->next = src->next; // 新节点指向最后一个节点
   10fe8:	e51b3008 	ldr	r3, [fp, #-8]
   10fec:	e5932004 	ldr	r2, [r3, #4]
   10ff0:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10ff4:	e5832004 	str	r2, [r3, #4]
  src->next = new;	 // 最后节点指向新节点
   10ff8:	e51b3008 	ldr	r3, [fp, #-8]
   10ffc:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   11000:	e5832004 	str	r2, [r3, #4]
  printf("src->next = new %p:%p\n", src->next, new);
   11004:	e51b3008 	ldr	r3, [fp, #-8]
   11008:	e5933004 	ldr	r3, [r3, #4]
   1100c:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   11010:	e1a01003 	mov	r1, r3
   11014:	e59f0018 	ldr	r0, [pc, #24]	; 11034 <insert+0xf4>
   11018:	ebfffcd9 	bl	10384 <printf@plt>

  return head;
   1101c:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
}
   11020:	e1a00003 	mov	r0, r3
   11024:	e24bd004 	sub	sp, fp, #4
   11028:	e8bd8800 	pop	{fp, pc}
   1102c:	000115b8 	.word	0x000115b8
   11030:	000115d0 	.word	0x000115d0
   11034:	000115f0 	.word	0x000115f0

00011038 <display>:

void display(struct list * node)
{
   11038:	e92d4800 	push	{fp, lr}
   1103c:	e28db004 	add	fp, sp, #4
   11040:	e24dd010 	sub	sp, sp, #16
   11044:	e50b0010 	str	r0, [fp, #-16]
  struct list * src, * des;

  src = node;
   11048:	e51b3010 	ldr	r3, [fp, #-16]
   1104c:	e50b300c 	str	r3, [fp, #-12]
  des = node->next;
   11050:	e51b3010 	ldr	r3, [fp, #-16]
   11054:	e5933004 	ldr	r3, [r3, #4]
   11058:	e50b3008 	str	r3, [fp, #-8]

  while(des != src){
   1105c:	ea000007 	b	11080 <display+0x48>
    printf(" %d ->",des->num);
   11060:	e51b3008 	ldr	r3, [fp, #-8]
   11064:	e5933000 	ldr	r3, [r3]
   11068:	e1a01003 	mov	r1, r3
   1106c:	e59f002c 	ldr	r0, [pc, #44]	; 110a0 <display+0x68>
   11070:	ebfffcc3 	bl	10384 <printf@plt>
    des=des->next;
   11074:	e51b3008 	ldr	r3, [fp, #-8]
   11078:	e5933004 	ldr	r3, [r3, #4]
   1107c:	e50b3008 	str	r3, [fp, #-8]
  struct list * src, * des;

  src = node;
  des = node->next;

  while(des != src){
   11080:	e51b2008 	ldr	r2, [fp, #-8]
   11084:	e51b300c 	ldr	r3, [fp, #-12]
   11088:	e1520003 	cmp	r2, r3
   1108c:	1afffff3 	bne	11060 <display+0x28>
    printf(" %d ->",des->num);
    des=des->next;
  }
  printf("\n\n");
   11090:	e59f000c 	ldr	r0, [pc, #12]	; 110a4 <display+0x6c>
   11094:	ebfffcbd 	bl	10390 <puts@plt>
}
   11098:	e24bd004 	sub	sp, fp, #4
   1109c:	e8bd8800 	pop	{fp, pc}
   110a0:	00011608 	.word	0x00011608
   110a4:	00011610 	.word	0x00011610

000110a8 <main>:

main()
{ 
   110a8:	e92d4800 	push	{fp, lr}
   110ac:	e28db004 	add	fp, sp, #4
   110b0:	e24dd008 	sub	sp, sp, #8
  int i;
  struct list * node, * cur;

  node = create_circular_link();
   110b4:	ebffff7d 	bl	10eb0 <create_circular_link>
   110b8:	e50b000c 	str	r0, [fp, #-12]
  printf("node:%p\n", node);
   110bc:	e51b100c 	ldr	r1, [fp, #-12]
   110c0:	e59f0054 	ldr	r0, [pc, #84]	; 1111c <main+0x74>
   110c4:	ebfffcae 	bl	10384 <printf@plt>

  for(i = 1; i < 11; i++)
   110c8:	e3a03001 	mov	r3, #1
   110cc:	e50b3008 	str	r3, [fp, #-8]
   110d0:	ea000006 	b	110f0 <main+0x48>
    node = insert(node,i);
   110d4:	e51b1008 	ldr	r1, [fp, #-8]
   110d8:	e51b000c 	ldr	r0, [fp, #-12]
   110dc:	ebffff97 	bl	10f40 <insert>
   110e0:	e50b000c 	str	r0, [fp, #-12]
  struct list * node, * cur;

  node = create_circular_link();
  printf("node:%p\n", node);

  for(i = 1; i < 11; i++)
   110e4:	e51b3008 	ldr	r3, [fp, #-8]
   110e8:	e2833001 	add	r3, r3, #1
   110ec:	e50b3008 	str	r3, [fp, #-8]
   110f0:	e51b3008 	ldr	r3, [fp, #-8]
   110f4:	e353000a 	cmp	r3, #10
   110f8:	dafffff5 	ble	110d4 <main+0x2c>
    node = insert(node,i);

  printf("node:%p\n", node);
   110fc:	e51b100c 	ldr	r1, [fp, #-12]
   11100:	e59f0014 	ldr	r0, [pc, #20]	; 1111c <main+0x74>
   11104:	ebfffc9e 	bl	10384 <printf@plt>

  display(node); 
   11108:	e51b000c 	ldr	r0, [fp, #-12]
   1110c:	ebffffc9 	bl	11038 <display>
}
   11110:	e1a00003 	mov	r0, r3
   11114:	e24bd004 	sub	sp, fp, #4
   11118:	e8bd8800 	pop	{fp, pc}
   1111c:	00011208 	.word	0x00011208

Disassembly of section .fini:

00011120 <_fini>:
   11120:	e1a0c00d 	mov	ip, sp
   11124:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   11128:	e24cb004 	sub	fp, ip, #4
   1112c:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
